/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package kitaplaner.application;

import java.sql.Connection;
import java.sql.Date;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Enumeration;
import java.util.GregorianCalendar;
import java.util.Iterator;
import java.util.Locale;
import javax.swing.table.DefaultTableModel;
import javax.swing.tree.DefaultMutableTreeNode;
import kitaplaner.database.Database;
import kitaplaner.database.Fehltag;
import kitaplaner.database.Kita;
import kitaplaner.database.Mitarbeiter;
import kitaplaner.database.Urlaubstage;

/**
 *
 * @author yves
 */
public class FehltageApp {
    Kita kita = new Kita();
    Database db = new Database();
    MitarbeiterApp mApp;
    Connection conn;

    public FehltageApp(Kita kita, Connection conn)
    {
        this.conn = conn;
        this.kita = kita;
        this.mApp = new MitarbeiterApp(kita, conn);
    }
    
    public DefaultTableModel createFTOverview()
    {
        String[] columnNames = {"Vorname", "Nachname", "Datum", "Grund"};

        // Pull all data together
        ArrayList <Fehltag> ftListe = kita.getFehltage();
        ArrayList <Mitarbeiter> mitarbeiterListe = kita.getMa();

        String vorname = "";
        String nachname = "";
        String grund = "";
        Date fehltag = null;
        
        // create a table model to return later
        DefaultTableModel model = new DefaultTableModel();

        //insert Columns
        for (int i = 0 ; i < columnNames.length; i++)
        {
            model.addColumn(columnNames[i]);
        }
        int mitarbeiterID;

        for (int i = 0; i < ftListe.size(); i++)
        {
            // get data of employee
            mitarbeiterID = ftListe.get(i).getMaId();
            vorname = mApp.getMaById(mitarbeiterID).getVorname();
            nachname = mApp.getMaById(mitarbeiterID).getNachname();
            grund = ftListe.get(i).getFehlgrund();
            fehltag = (Date) ftListe.get(i).getDatum();
            
            // fill table  object
            Object []obj = {vorname, nachname, fehltag, grund};
            
            model.insertRow (model.getRowCount(), obj);
        }
        return model;
    }
    
    public DefaultTableModel createFTOverview(int mitarbeiterID, String jahr, String grund)
    {
        String[] columnNames = {"Vorname", "Nachname", "Datum", "Grund"};

        // Pull all data together
        ArrayList <Fehltag> ftListe = kita.getFehltage();
        ArrayList <Mitarbeiter> mitarbeiterListe = kita.getMa();

        String vorname = "";
        String nachname = "";
        Date fehltag = null;
        ArrayList sortedDates = new ArrayList();
        
        // create a table model to return later
        DefaultTableModel model = new DefaultTableModel();

        //insert Columns
        for (int i = 0 ; i < columnNames.length; i++)
        {
            model.addColumn(columnNames[i]);
        }
        
        for (int i = 0; i < ftListe.size(); i++)
        {
            // get data of employee
            if (ftListe.get(i).getMaId() == mitarbeiterID && 
                ftListe.get(i).getFehlgrund().equals(grund)) {
                
                mitarbeiterID = ftListe.get(i).getMaId();
                vorname = mApp.getMaById(mitarbeiterID).getVorname();
                nachname = mApp.getMaById(mitarbeiterID).getNachname();
                grund = ftListe.get(i).getFehlgrund();
                fehltag = (Date) ftListe.get(i).getDatum();

                // fill table  object
                sortedDates.add(fehltag);
//                Object []obj = {vorname, nachname, fehltag, grund};
//
//                model.insertRow (model.getRowCount(), obj);
           }
        }
        
        // sort by date
        Collections.sort(sortedDates);
        
        for (int j = 0; j < sortedDates.size(); j++) {
            Object []obj = {vorname, nachname, sortedDates.get(j), grund};

            model.insertRow (model.getRowCount(), obj);
        }

        return model;
    }
    
    public DefaultTableModel createFTSUMOverview(String jahr, String grund)
    {
        String[] columnNames = {"Vorname", "Nachname", "Gesamtanzahl Fehltage", "Grund"};

        // Pull all data together
        ArrayList <Fehltag> ftListe = kita.getFehltage();
        ArrayList <Mitarbeiter> mitarbeiterListe = kita.getMa();
        
        String vorname = "";
        String nachname = "";
        String grundFehltag = grund;
        String year = jahr;
        int sumFehltage = 0;

        // create a table model to return later
        DefaultTableModel model = new DefaultTableModel();

        //insert Columns
        for (int i = 0 ; i < columnNames.length; i++)
        {
            model.addColumn(columnNames[i]);
        }
        int mitarbeiterID;

        for (int i = 0; i < mitarbeiterListe.size(); i++)
        {
            // get data of employee
            mitarbeiterID = mitarbeiterListe.get(i).getId();
            
            vorname = mApp.getMaById(mitarbeiterID).getVorname();
            nachname = mApp.getMaById(mitarbeiterID).getNachname();
            
            sumFehltage = this.getSUMFehltageMitarbeiter(mitarbeiterID, jahr, grund);
            
            
            // fill table  object
            Object []obj = {vorname, nachname, sumFehltage, grundFehltag};
            
            model.insertRow (model.getRowCount(), obj);
        }
        return model;
    }
    
    public boolean insertFehltag(int mitarbeiterID, Date urlaubsDatum, String grund)
    {
        Fehltag fehltag = new Fehltag();
        
        fehltag.setMaId(mitarbeiterID);
        fehltag.setDatum(urlaubsDatum);
        fehltag.setFehlgrund(grund);

        conn = db.checkConnection(conn);
        Boolean success = fehltag.save(fehltag, conn);
        kita.setFehltage(db.getFehltage(conn));

        return success;
    }
    
    public boolean insertFehltag(int mitarbeiterID, Date urlaubVon, Date urlaubBis, String grund) {
        
        boolean success = false;
        Date currentDate = urlaubVon;
        
        Calendar c = Calendar.getInstance();
        c.setTime(urlaubVon);
        Date endDate = urlaubBis;

        while (c.getTime().before(endDate)) {
           // Sonntage und Samstage werden im Batch-Input nicht eingefügt.
            if (c.get(Calendar.DAY_OF_WEEK) != Calendar.SUNDAY &&
                c.get(Calendar.DAY_OF_WEEK) != Calendar.SATURDAY  ) {
                
                currentDate.setTime(c.getTimeInMillis());
                
                Fehltag fehltag = new Fehltag();
                fehltag.setMaId(mitarbeiterID);
                fehltag.setFehlgrund(grund);
                fehltag.setDatum(currentDate);

                conn = db.checkConnection(conn);
                success = fehltag.save(fehltag, conn);
                
            }

           c.add(Calendar.DAY_OF_WEEK, 1);
        }
        
        kita.setFehltage(db.getFehltage(conn));
        return success;
    }
    
    public Object [] createComboBoxTextByMa(int mitarbeiterID)
    {
        Object [] comboItems;

        ArrayList <Fehltag> ftListe = kita.getFehltage();
        ArrayList ftListeMitarbeiter = new ArrayList();

        for (int i = 0; i < ftListe.size(); i++)
        {
            if (ftListe.get(i).getMaId() == mitarbeiterID)
            {
                ftListeMitarbeiter.add(ftListe.get(i).getDatum());
            }
        }
        
        comboItems = ftListeMitarbeiter.toArray();

        return comboItems;
    }

    public ArrayList<Fehltag> getFehltageMitarbeiter(int mitarbeiterID) 
    {
        conn = db.checkConnection(conn);
        ArrayList<Fehltag> all = db.getFehltage(conn);
        ArrayList<Fehltag> result = new ArrayList();
        
        for (int i = 0; i < all.size(); i++) {
            if (all.get(i).getMaId() == mitarbeiterID) {
                result.add(all.get(i));
            }
        }
        
        return result;
    }
    
    public ArrayList<Fehltag> getFehltageMitarbeiterByGrund(int mitarbeiterID, String grund) {
        conn = db.checkConnection(conn);
        ArrayList<Fehltag> all = db.getFehltage(conn);
        ArrayList<Fehltag> result = new ArrayList();

        for (int i = 0; i < all.size(); i++) {
            if (all.get(i).getMaId() == mitarbeiterID && all.get(i).getFehlgrund().equals(grund)) {
                result.add(all.get(i));
            }
        }

        return result;
    }

    public ArrayList<Fehltag> getFehltageMitarbeiterByGrund(int mitarbeiterID, String grund, String jahr) {
        conn = db.checkConnection(conn);
        ArrayList<Fehltag> all = db.getFehltage(conn);
        ArrayList<Fehltag> result = new ArrayList();
        Integer fehltagJahr = null;

        for (int i = 0; i < all.size(); i++) {
            fehltagJahr = all.get(i).getYear(all.get(i).getDatum());

            if (grund.equals("Alle") && jahr.equals("Alle")) {

                if (all.get(i).getMaId() == mitarbeiterID) {
                    result.add(all.get(i));
                }
            }else if (jahr.equals("Alle")) {
                if (all.get(i).getMaId() == mitarbeiterID && all.get(i).getFehlgrund().equals(grund)) {
                    result.add(all.get(i));
                }
            } else if (grund.equals("Alle")) {
                if (all.get(i).getMaId() == mitarbeiterID && fehltagJahr.toString().equals(jahr)) {
                    result.add(all.get(i));
                }
            } else if (!jahr.equals("Alle") && !grund.equals("Alle")) {
                if (all.get(i).getMaId() == mitarbeiterID && all.get(i).getFehlgrund().equals(grund) && fehltagJahr.toString().equals(jahr)) {
                    result.add(all.get(i));
                }
            }
        }
        return result;       
    }

    public javax.swing.JTree createTreeView(ArrayList<Fehltag> fehltage) {

        // create root, branches and leafs
        DefaultMutableTreeNode root = new DefaultMutableTreeNode("Root");
        DefaultMutableTreeNode yearBranch = new DefaultMutableTreeNode("Jahr");
        DefaultMutableTreeNode monthBranch = new DefaultMutableTreeNode("Monate! - Branch");
        DefaultMutableTreeNode dayLeafs = new DefaultMutableTreeNode("Tage! - Leaf");
        
        String grund = fehltage.get(0).getFehlgrund();
        Integer year = 0;
        String month = null;
        String day = null;
        Boolean monthExists = false;
        Boolean yearExists = false;
        
        Calendar calendar = new GregorianCalendar();
        // Sort the treedata, working on sorted lists is easy
        ArrayList dates = new ArrayList();
        
        for (int i = 0; i< fehltage.size(); i++) {
            Date currentDate = (Date) fehltage.get(i).getDatum();
            dates.add(currentDate);
            //System.out.println(currentDate);
        }

        Collections.sort(dates);
        
        //System.out.println("After Sort:------------------");
//        for (Iterator i = dates.iterator(); i.hasNext();) {
//            Date currentDate = (Date) i.next();
//            //System.out.println(currentDate);
//        }
        
        
        // get data and grow tree
        Iterator it = dates.iterator();

        while (it.hasNext()) {
            Date currentDate = (Date) it.next();
            calendar.setTime(currentDate);

            year = calendar.get(Calendar.YEAR);
            month = calendar.getDisplayName(Calendar.MONTH, Calendar.LONG, Locale.GERMAN);
            day = calendar.get(Calendar.DAY_OF_MONTH) + " " + calendar.getDisplayName(Calendar.DAY_OF_WEEK, Calendar.LONG, Locale.GERMAN);

            // Baum ist komplett leer, schreibe jahresknoten
            if (root.getChildCount() == 0) {
                yearBranch = new DefaultMutableTreeNode(year.toString());
                monthBranch = new DefaultMutableTreeNode(month);
                dayLeafs = new DefaultMutableTreeNode(day+" - "+grund);
                System.out.println(dayLeafs.getUserObject().toString());
                

                monthBranch.add(dayLeafs);
                yearBranch.add(monthBranch);
                root.add(yearBranch);
            } else {
                // Baum nicht leer, überpüfe ob Jahrknoten vorhanden
                Enumeration yearNodeTraverse = root.children();
                while (yearNodeTraverse.hasMoreElements()) {
                    yearBranch = (DefaultMutableTreeNode) yearNodeTraverse.nextElement();
                    // Jahresknoten ist vorhanden, überprüfe ob Monatsknoten vorhanden
                    if (yearBranch.getUserObject().toString().equals(year.toString())) {
                        
                        yearExists = true;
                        Enumeration childrenOfRoot = yearBranch.children();
                        
                        while (childrenOfRoot.hasMoreElements()) {
                            monthBranch = (DefaultMutableTreeNode) childrenOfRoot.nextElement();

                            // monatsknoten gefunden
                            if (monthBranch.getUserObject().toString().equals(month)) {
                                dayLeafs = new DefaultMutableTreeNode(day+" - "+grund);
                                monthBranch.add(dayLeafs);
                                monthExists = true;

                            } else { 
                                monthExists = false;
                            }
                        }

                        if (!monthExists) {// Monatsknoten nicht gefunden, aber das jahr füge monat in das jahr ein.
                            dayLeafs = new DefaultMutableTreeNode(day+" - "+grund);
                            monthBranch = new DefaultMutableTreeNode(month);

                            monthBranch.add(dayLeafs);
                            yearBranch.add(monthBranch);
                        }
                    } else 
                    {
                        yearExists = false;
                    }
                }
                if (!monthExists && !yearExists) {// Jahresknoten nicht vorhanden, dann monat auch nicht vorhanden, einfach einfügen
                    yearBranch = new DefaultMutableTreeNode(year.toString());
                    monthBranch = new DefaultMutableTreeNode(month);
                    dayLeafs = new DefaultMutableTreeNode(day+" - "+grund);

                    monthBranch.add(dayLeafs);
                    yearBranch.add(monthBranch);
                    root.add(yearBranch);
                }
            }
        }

        javax.swing.JTree tree = new javax.swing.JTree(root);
        tree.setRootVisible(false);
        return tree;
    }

    public boolean deleteFehltag(int mitarbeiterID, Date dateToDelete) {
        
        boolean success = false;
        ArrayList <Fehltag> fehltage = kita.getFehltage();
        int id = -1;
        for (int i = 0; i < fehltage.size(); i ++)
        {
            if (fehltage.get(i).getDatum() == dateToDelete && fehltage.get(i).getMaId() == mitarbeiterID)
            {
                id = fehltage.get(i).getId();
                fehltage.remove(i);
            }
        }
        
        conn = db.checkConnection(conn);
        success = db.deleteFehltag(conn, id);

        kita.setFehltage(fehltage);
        
        return success;
    }
    
    public int getSUMFehltageMitarbeiter(int mitarbeiterID, String jahr, String grund)
    {
        int fehltage = 0;
        
        fehltage = this.getFehltageMitarbeiterByGrund(mitarbeiterID, grund, jahr).size();

        return fehltage;
    }
    
    public int getSUMFehltageMitarbeiter(int mitarbeiterID, String jahr)
    {
        int fehltage = 0;
        
        fehltage = this.getFehltageMitarbeiterByGrund(mitarbeiterID, "Alle", jahr).size();

        return fehltage;
    }
}
